package com.cn.wanxi.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Person {
//    对第一阶段要抽象出类，不需要进行赋值

    //    脸型
//    鞋子
//    年龄 18 字面量
//    标识符 变量名
//    age=18;  = 赋值运算符
//    face=瓜子脸
//    我们需要将变量转载某个地方 容器
//    数据类型？
//    Java语言的数据类型？
//    基本
//    八大基本类型
//    boolean  1个bit位
//    byte      1个字节   八个bit位
//    char short      2
//    int float         4
//    long   double     8
//    四种基本类型
//    整型 byte Byte short Short int Integer long Long
//    浮点型 float Float double Double
//    字符型 char Character
//    布尔型 boolean Boolean
//    默認值 字节数  范围
//    引用
//    强语言 编程语言  要求严格
//            裤子
//    行为
//    public static final String publicName = "publicName";
//    private String privateName = "privateName";
//    protected String protectedName = "protectedName";
//    String name = "name";
//
//    public Object aa(String name) {
//        System.out.println(11);
//        return "";
//    }

//    public static void main(String[] args) {
//        修饰符
//        1.在同一个类里面四种修饰符都能调用
//        2.如果在不同的类里面  private的修饰符不能调用
//        3.如果在不同包里面只能调用public
//        4.注意：以后对象里面所有的属性全部默认private  封装---把自己的隐私藏起来
//        5.protected的目的就是为了子类可以得到。受保护的
//        String name = new Person().publicName;
//        System.out.println(name);
//        byte 有符号位   -128 127
//        byte 无符号    256
//        byte age = 20;//20数据类型位int，默认整数数据类型位int，默认小数数据类型位double

//        byte age=1;
//        char c='空'; //空字符
//        double d=2;
//        float f=2.9F;
//        long l=11L;
//        l= (long) d;
//        boolean b=true;
//        age=b;//布尔值和其他类型都不能相互转换
//        b=age;
//        d=l;
//        c= (char) age;
//        age=c;
//        System.out.println(age);//所有的字符都有一个对应的ascii码，
//        String s="  ";
//        short height=55;
//        height= (short) age;
//        age=height;
//        引入包装类,对于每个基本类型都有一个属于自己的包装类
//        包装类属于类，属于引用类型
//        装箱和拆箱  ---- 从基本类型到包装类  装箱    反之叫拆箱
//         变量的命名规则？一个完整的变量命名怎么命名？定义变量怎么定义？
//        标识符：需要自己命名的东西？
//        命名规则
//        1.包名  全部小写  user.role.retional
//        2.类名   大驼峰
//        3.属性名   小驼峰
//        4.方法名   小驼峰
//        5.常量名   全大写 USER_ROLE_RETIONAL
//        定义变量?
//        权限修饰符（访问修饰符）
//         (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
//        private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
//        public : 对所有类可见。使用对象：类、接口、变量、方法
//        protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
//        权限修饰符可以修饰哪些？属性，方法，类
//        特征修饰符（非访问修饰符）
//        static   静态 用法
//        修饰类方法  调用该方法时，直接通过类.方法名
//        修饰类属性  类.属性名
//        加载当前类的时候会在内存里面开辟一个空间
//        final 最终的，不可改变的
//        1.修饰类  表示类不能被继承
//        2.修饰属性  表示常量  值不能改变
//        3.修饰方法  不能被重写
//        重写：子类和父类  方法名一样，参数类型和个数一样，返回类型子类小于等于父类
//        重载：方法名相同，参数类型和个数不一样 不区分返回值
//        synchronized 同步 线程
//        abstract  抽象
//        数据类型
//        变量名
//        赋值运算符
//        字面量；

//    }
//    public static final String PUBLIC_NAME = "publicName";
//    接口里面可以定义方法和属性，方法默认公有，默认抽象，属性默认位常量
//    接口里面可以写普通方法，只不过必须有default修饰
//    一个类的组成部分？

    /**
     * 1.包
     * 2.类名
     * 3.属性
     * 4.方法
     * 5.构造方法
     * 反射---拿到当前的类对象
     * 一个完整的方法定义
     * 权限修饰符  特征修饰符  返回值类型  方法名（参数）异常{
     * 执行体
     * return null;
     * }
     * 方法--构造方法--代码块
     * 构造方法？主要目的？
     * 实例化对象 得到对象的值   调用方法和属性
     * 构造方法是否有返回值？ 有，对象本身
     * 构造方法可以有参数
     * 一个类里面有一个默认的无参数的构造方法
     * 如果有一个有参数的构造方法，则无参数的构造方法失效
     * 编译对象时，只有静态代码块会执行
     * 如果创建对象后在执行，则先执行静态代码块，在执行代码块，在执行构造方法
     * static代码块用于第一个执行
     * 先执行静态代码块，如果有父类，先执行父类的静态代码块，在执行子类的静态代码块
     * 当静态代码块执行完在执行父类的代码块和构造方法，然后在执行子类的代码块和构造方法
     * 用于时按照静态代码块书写顺序执行
     * 类的执行顺序？
     */
//    public static void main(String[] args) {
//        System.out.println("main");
//        Person person = new Person();
//
//    }
//
//    Person() {
//        System.out.println("Person");
//    }
//
//    Person(String name) {
//        System.out.println("Personname");
//    }
//
//    {
//        System.out.println("{}");
//    }
//
//    static {
//        System.out.println("static{}");
//    }

    /**
     * 数组和集合
     * 1.数组？Java 语言中提供的数组是用来存储固定大小的同类型元素。
     * 2.数组的定义？
     * 静态定义
     * int[] array={1，2，4，7}；
     * 动态定义
     * int[] array=new int[8];//空对象，指里面的值为空
     * 3.数组的运用？应用场景
     * 4.数组的操作？数据----增删查改
     * StringBuilder 和String 和StringBuffer区别？
     * [1, 4, 6, 8]
     * 集合：
     * 不用定义长度
     * 长度可变
     * 数组和集合的区别？
     * 集合定义？
     * List list=new ArrayList<>();
     */
//    public static void main(String[] args) {
//        int[] array ={1,4,6,8};
//        array[0]=2;
//        array[4]=5;//数组只要定义后不能增加元素，删除？
//        System.out.println(Arrays.toString(array));
//        String[] array = new String[8];
//        array[4]="a";
//        System.out.println(Arrays.toString(array));
//        List list = new ArrayList<>();//定义一个空的集合
//        list.add("a");
//        list.add(1);
//        list.add(true);
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i).getClass());
//        }
//        System.out.println(list);
//        org.apache.commons.lang.StringUtils.join(list.toArray(),separator);

//    }
    /**
     * 第二阶段  Java web  项目程序
     * servlet +jsp
     * servlet是什么？
     * 引用场景？
     * 必须要引入servlet的jar包
     * 项目运行必须放入容器里面运行？tomcat
     * 下载tomcat
     * 项目框架搭建完成
     * servlet 三层架构
     * 1.页面控制层
     *   页面和jsp页面相关  数据从当前层进行传递 和页面一一对应
     * 2.服务逻辑层
     *      写逻辑代码
     * 3.数据实现层
     *      封装数据
     * 4.实体层
     * mvc
     * m model 实体层
     * v view  视图层
     * c controller  控制层
     * jsp?目的？页面展示 取消js
     * <%  %>写Java代码的
     * jsp页面有Java代码  耦合度很高，不容易维护
     */
}
